home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2003 November A / PCWK1103A.iso / ABBYY FineReader 7.0 PRO / data1.cab / gs_res.ps < prev    next >
Text File  |  2002-02-23  |  30KB  |  928 lines
  1. %    Copyright (C) 1994, 1996, 1997, 1998, 1999, 2000 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This software is provided AS-IS with no warranty, either express or
  4. % implied.
  5. % 
  6. % This software is distributed under license and may not be copied,
  7. % modified or distributed except as expressly authorized under the terms
  8. % of the license contained in the file LICENSE in this distribution.
  9. % 
  10. % For more information about licensing, please refer to
  11. % http://www.ghostscript.com/licensing/. For information on
  12. % commercial licensing, go to http://www.artifex.com/licensing/ or
  13. % contact Artifex Software, Inc., 101 Lucas Valley Road #110,
  14. % San Rafael, CA  94903, U.S.A., +1(415)492-9861.
  15.  
  16. % $Id: gs_res.ps,v 1.16.2.1 2002/02/22 19:45:55 ray Exp $
  17. % Initialization file for Level 2 resource machinery.
  18. % When this is run, systemdict is still writable,
  19. % but (almost) everything defined here goes into level2dict.
  20.  
  21. level2dict begin
  22.  
  23. (BEGIN RESOURCES) VMDEBUG
  24.  
  25. % We keep track of (global) instances with another entry in the resource
  26. % dictionary, an .Instances dictionary.  For categories with implicit
  27. % instances, the values in .Instances are the same as the keys;
  28. % for other categories, the values are [instance status size].
  29.  
  30. % Note that the dictionary that defines a resource category is stored
  31. % in global VM.  The PostScript manual says that each category must
  32. % manage global and local instances separately.  However, objects in
  33. % global VM other than systemdict can't reference objects in local VM.
  34. % This means that the resource category dictionary, which would otherwise be
  35. % the obvious place to keep track of the instances, can't be used to keep
  36. % track of local instances.  Instead, we define a dictionary in local VM
  37. % called localinstancedict, in which the key is the category name and
  38. % the value is the analogue of .Instances for local instances.
  39.  
  40. % We don't currently implement automatic resource unloading.
  41. % When and if we do, it should be hooked to the garbage collector.
  42. % However, Ed Taft of Adobe says their interpreters don't implement this
  43. % either, so we aren't going to worry about it for a while.
  44.  
  45. currentglobal false setglobal systemdict begin
  46.   /localinstancedict 5 dict
  47.   .forcedef    % localinstancedict is local, systemdict is global
  48. end true setglobal
  49. /.emptydict 0 dict readonly def
  50. setglobal
  51.  
  52. % Resource category dictionaries have the following keys (those marked with
  53. % * are optional):
  54. %    Standard, defined in the Red Book:
  55. %        Category (name)
  56. %        *InstanceType (name)
  57. %        DefineResource
  58. %            <key> <instance> DefineResource <instance>
  59. %        UndefineResource
  60. %            <key> UndefineResource -
  61. %        FindResource
  62. %            <key> FindResource <instance>
  63. %        ResourceStatus
  64. %            <key> ResourceStatus <status> <size> true
  65. %            <key> ResourceStatus false
  66. %        ResourceForAll
  67. %            <template> <proc> <scratch> ResourceForAll -
  68. %        *ResourceFileName
  69. %            <key> <scratch> ResourceFileName <filename>
  70. %    Additional, specific to our implementation:
  71. %        .Instances (dictionary)
  72. %        .LocalInstances
  73. %            - .LocalInstances <dict>
  74. %        .GetInstance
  75. %            <key> .GetInstance <instance> -true-
  76. %            <key> .GetInstance -false-
  77. %        .CheckResource
  78. %            <key> <value> .CheckResource <key> <value> <ok>
  79. %              (or may give an error if not OK)
  80. %        .DoLoadResource
  81. %            <key> .DoLoadResource <key> (may give an error)
  82. %        .LoadResource
  83. %            <key> .LoadResource - (may give an error)
  84. %        .ResourceFile
  85. %            <key> .ResourceFile <file> -true-
  86. %            <key> .ResourceFile <key> -false-
  87. %        .ResourceFileStatus
  88. %            <key> .ResourceFileStatus 2 <vmusage> -true-
  89. %            <key> .ResourceFileStatus -false-
  90. % All the above procedures expect that the top dictionary on the d-stack
  91. % is the resource dictionary.
  92.  
  93. % Define enough of the Category category so we can define other categories.
  94. % The dictionary we're about to create will become the Category
  95. % category definition dictionary.
  96.  
  97. % .findcategory and .resourceexec are only called from within the
  98. % implementation of the resource 'operators', so they doesn't have to worry
  99. % about cleaning up the stack if they fail (the interpreter's stack
  100. % protection machinery for pseudo-operators takes care of this).
  101. /.findcategory {    % <name> .findcategory -
  102.             %   (pushes the category on the dstack)
  103.   /Category findresource begin
  104. } bind def
  105.  
  106. /.resourceexec {    % <key> /xxxResource .resourceexec -
  107.             %   (also pops the category from the dstack)
  108.   load exec end
  109. } bind def
  110.  
  111. % .getvminstance treats instances on disk as undefined.
  112. /.getvminstance {    % <key> .getvminstance <instance> -true-
  113.             % <key> .getvminstance -false-
  114.   .GetInstance {
  115.     dup 1 get 2 ne { true } { pop false } ifelse
  116.   } {
  117.     false
  118.   } ifelse
  119. } bind def
  120.  
  121. 20 dict begin
  122.  
  123.         % Standard entries
  124.  
  125. /Category /Category def
  126. /InstanceType /dicttype def
  127.  
  128. /DefineResource {
  129.     .CheckResource {
  130.       dup /Category 3 index cvlit .growput
  131.       dup [ exch 0 -1 ] exch
  132.       .Instances 4 2 roll put
  133.         % Make the Category dictionary read-only.  We will have to
  134.         % use .forceput / .forcedef later to replace the dummy,
  135.         % empty .Instances dictionary with the real one later.
  136.       readonly
  137.     } {
  138.       /defineresource load /typecheck signalerror
  139.     } ifelse
  140. } bind def
  141. /FindResource        % (redefined below)
  142.     { .Instances exch get 0 get
  143.     } bind def
  144.  
  145.         % Additional entries
  146.  
  147. /.Instances 30 dict def
  148. .Instances /Category [currentdict 0 -1] put
  149.  
  150. /.LocalInstances 0 dict def
  151. /.GetInstance
  152.     { .Instances exch .knownget
  153.     } bind def
  154. /.CheckResource
  155.     { dup gcheck currentglobal and
  156.        { /DefineResource /FindResource /ResourceForAll /ResourceStatus
  157.          /UndefineResource }
  158.        { 2 index exch known and }
  159.       forall
  160.       not { /defineresource load /invalidaccess signalerror } if
  161.       true
  162.     } bind def
  163.  
  164. .Instances end begin    % for the base case of findresource
  165.  
  166. (END CATEGORY) VMDEBUG
  167.  
  168. % Define the resource operators.  We use the "stack protection" feature of
  169. % odef to make sure the stacks are restored properly on an error.
  170. % This requires that the operators not pop anything from the stack until
  171. % they have executed their logic successfully.  We can't make this
  172. % work for resourceforall, because the procedure it executes mustn't see
  173. % the operands of resourceforall on the stack, but we can make it work for
  174. % the others.
  175.  
  176. % findresource is the only operator that needs to bind //Category.
  177. /findresource {        % <key> <category> findresource <instance>
  178.     2 copy dup /Category eq
  179.       { pop //Category 0 get begin } { .findcategory } ifelse
  180.     /FindResource .resourceexec exch pop exch pop
  181. } bind
  182. end        % .Instances of Category
  183. odef
  184.  
  185. /defineresource {    % <key> <instance> <category> defineresource <instance>
  186.     3 copy .findcategory
  187.     currentdict /InstanceType known {
  188.       dup type InstanceType ne {
  189.         dup type /packedarraytype eq InstanceType /arraytype eq and
  190.         not { /defineresource load /typecheck signalerror } if
  191.       } if
  192.     } if
  193.     /DefineResource .resourceexec
  194.     4 1 roll pop pop pop
  195. } bind odef
  196. % We must prevent resourceforall from automatically restoring the stacks,
  197. % because we don't want the stacks restored if proc causes an error.
  198. % On the other hand, resourceforall is defined in the PLRM as an operator,
  199. % so it must have type /operatortype.  We hack this by taking advantage of
  200. % the fact that the interpreter optimizes tail calls, so stack protection
  201. % doesn't apply to the very last token of an operator procedure.
  202. /resourceforall1 {    % <template> <proc> <scratch> <category> resourceforall1 -
  203.     dup /Category findresource begin
  204.     /ResourceForAll load
  205.         % Make sure we can recover the original operands.
  206.         % We must create the array in local VM, in case any of the
  207.         % operands are local.
  208.         % Stack: ...operands... proc
  209.     5 copy pop .currentglobal false .setglobal 5 1 roll
  210.     4 packedarray exch .setglobal count
  211.         % Stack: ...operands... proc saved count
  212.     4 -1 roll pop        % pop the category
  213.     /stopped load 3 1 roll
  214.     3 .execn
  215.         % Stack: ... stopped saved count
  216.     3 -1 roll {
  217.       .currentstackprotect {
  218.         % The count is the original stack depth + 2.
  219.         count exch 4 sub sub { exch pop } repeat
  220.         aload pop end
  221.       } {
  222.         % Don't restore the stacks.
  223.         pop pop
  224.       } ifelse stop
  225.     } {
  226.       pop pop end
  227.     } ifelse
  228. } bind def
  229. /resourceforall {    % <template> <proc> <scratch> <category> resourceforall1 -
  230.     //resourceforall1 exec        % see above
  231. } bind odef
  232. /resourcestatus {    % <key> <category> resourcestatus <status> <size> true
  233.             % <key> <category> resourcestatus false
  234.     2 copy .findcategory /ResourceStatus .resourceexec
  235.      { 4 2 roll pop pop true } { pop pop false } ifelse
  236. } bind odef
  237. /undefineresource {    % <key> <category> undefineresource -
  238.     2 copy .findcategory /UndefineResource .resourceexec pop pop
  239. } bind odef
  240.  
  241. % Define the system parameters used for the Generic implementation of
  242. % ResourceFileName.
  243. systemdict begin
  244. currentdict /pssystemparams known not {
  245.   /pssystemparams 10 dict readonly def
  246. } if
  247. pssystemparams begin
  248.   /FontResourceDir (/Resource/Font/) readonly .forcedef    % pssys'params is r-o
  249.   /GenericResourceDir (/Resource/) readonly .forcedef    % pssys'params is r-o
  250.   /GenericResourcePathSep (/) readonly .forcedef    % pssys'params is r-o
  251. end
  252. end
  253.  
  254. % Define the generic algorithm for computing resource file names.
  255. /.rfnstring 100 string def
  256. /.genericrfn        % <key> <scratch> <prefix> .genericrfn <filename>
  257.  { 3 -1 roll //.rfnstring cvs concatstrings exch copy
  258.  } bind def
  259.  
  260. % Define a procedure for making a packed array in local VM.
  261. /.localpackedarray {    % <obj1> ... <objn> <n> .localpackedarray <packedarray>
  262.   .currentglobal false .setglobal 1 index 2 add 1 roll
  263.   packedarray exch .setglobal
  264. } bind def
  265.  
  266. % Define the Generic category.
  267.  
  268. /Generic mark
  269.  
  270.         % Standard entries
  271.  
  272. % We're still running in Level 1 mode, so dictionaries won't expand.
  273. % Leave room for the /Category entry.
  274. /Category null
  275.  
  276. % Implement the body of Generic resourceforall for local, global, and
  277. % external cases.  'args' is [template proc scratch resdict].
  278. /.enumerateresource {    % <key> [- <proc> <scratch>] .enumerateresource -
  279.   1 index type dup /stringtype eq exch /nametype eq or {
  280.     exch 1 index 2 get cvs exch
  281.   } if
  282.     % Use .setstackprotect to prevent the stacks from being restored if
  283.     % an error occurs during execution of proc.
  284.   1 get false .setstackprotect exec true .setstackprotect
  285. } bind def
  286. /.localresourceforall {        % <key> <value> <args> .localr'forall -
  287.   exch pop
  288.   2 copy 0 get .stringmatch { .enumerateresource } { pop pop } ifelse
  289. } bind def
  290. /.globalresourceforall {    % <key> <value> <args> .globalr'forall -
  291.   exch pop
  292.   2 copy 0 get .stringmatch {
  293.     dup 3 get begin .LocalInstances end 2 index known not {
  294.       .enumerateresource
  295.     } if
  296.   } {
  297.     pop pop
  298.   } ifelse
  299. } bind def
  300. /.externalresourceforall {    % <filename> <len> <args> .externalr'forall -
  301.   3 1 roll 1 index length 1 index sub getinterval exch
  302.   dup 3 get begin .Instances .LocalInstances end
  303.         % Stack: key args insts localinsts
  304.   3 index known {
  305.     pop pop pop
  306.   } {
  307.     2 index known { pop pop } { .enumerateresource } ifelse
  308.   } ifelse
  309. } bind def
  310.  
  311. /DefineResource {
  312.     .CheckResource
  313.        { dup [ exch 0 -1 ]
  314.             % Stack: key value instance
  315.          currentglobal
  316.           { false setglobal 2 index UndefineResource    % remove local def if any
  317.         true setglobal
  318.         .Instances dup //.emptydict eq {
  319.           pop 3 dict
  320.             % As noted above, Category dictionaries are read-only,
  321.             % so we have to use .forcedef here.
  322.           /.Instances 1 index .forcedef    % Category dict is read-only
  323.         } if
  324.           }
  325.           { .LocalInstances dup //.emptydict eq
  326.              { pop 3 dict localinstancedict Category 2 index put
  327.          }
  328.         if
  329.           }
  330.          ifelse
  331.             % Stack: key value instance instancedict
  332.          3 index 2 index .growput
  333.             % Now make the resource value read-only.
  334.          0 2 copy get { readonly } .internalstopped pop
  335.          dup 4 1 roll put exch pop exch pop
  336.        }
  337.        { /defineresource load /typecheck signalerror
  338.        }
  339.     ifelse
  340. } bind executeonly        % executeonly to prevent access to .forcedef
  341. /UndefineResource
  342.     {  { dup 2 index .knownget
  343.           { dup 1 get 1 ge
  344.          { dup 0 null put 1 2 put pop pop }
  345.          { pop exch .undef }
  346.         ifelse
  347.           }
  348.           { pop pop
  349.           }
  350.          ifelse
  351.        }
  352.       currentglobal
  353.        { 2 copy .Instances exch exec
  354.        }
  355.       if .LocalInstances exch exec
  356.     } bind
  357. % Because of some badly designed code in Adobe's CID font downloader that
  358. % makes findresource and resourcestatus deliberately inconsistent with each
  359. % other, the default FindResource must not call ResourceStatus if there is
  360. % an instance of the desired name already defined in VM.
  361. /FindResource {
  362.     dup .getvminstance {
  363.       exch pop 0 get
  364.     } {
  365.       dup ResourceStatus {
  366.         pop 1 gt {
  367.           .DoLoadResource .getvminstance not {
  368.         /findresource load /undefinedresource signalerror
  369.           } if 0 get
  370.         } {
  371.           .GetInstance pop 0 get
  372.         } ifelse
  373.       } {
  374.        /findresource load /undefinedresource signalerror
  375.       } ifelse
  376.     } ifelse
  377. } bind
  378. % Because of some badly designed code in Adobe's CID font downloader, the
  379. % definition of ResourceStatus for Generic and Font must be the same (!).
  380. % We patch around this by using an intermediate .ResourceFileStatus procedure.
  381. /ResourceStatus {
  382.     dup .GetInstance {
  383.       exch pop dup 1 get exch 2 get true
  384.     } {
  385.       .ResourceFileStatus
  386.     } ifelse
  387. } bind
  388. /.ResourceFileStatus {
  389.     .ResourceFile { closefile 2 -1 true } { pop false } ifelse
  390. } bind
  391. /ResourceForAll {
  392.         % **************** Doesn't present instance groups in
  393.         % **************** the correct order yet.
  394.         % Construct a new procedure to hold the arguments.
  395.         % All objects constructed here must be in local VM to avoid
  396.         % a possible invalidaccess.
  397.     currentdict 4 .localpackedarray    % [template proc scratch resdict]
  398.         % We must pop the resource dictionary off the dict stack
  399.         % when doing the actual iteration, and restore it afterwards.
  400.     .currentglobal not {
  401.       .LocalInstances length 0 ne {
  402.         % We must do local instances, and do them first.
  403.         //.localresourceforall {exec} 0 get 3 .localpackedarray cvx
  404.         .LocalInstances exch {forall} 0 get 1 index 0 get
  405.         currentdict end 3 .execn begin
  406.       } if
  407.     } if
  408.         % Do global instances next.
  409.     //.globalresourceforall {exec} 0 get 3 .localpackedarray cvx
  410.     .Instances exch cvx {forall} 0 get 1 index 0 get
  411.     currentdict end 3 .execn begin
  412.     currentdict /ResourceFileName known {
  413.         % Finally, do instances stored on files.
  414.       dup 0 get 100 string ResourceFileName
  415.       dup length 2 index 0 get length sub 3 -1 roll
  416.       //.externalresourceforall {exec} 0 get 4 .localpackedarray cvx
  417.       100 string {filenameforall} 0 get
  418.       currentdict end 2 .execn begin null    % for pop
  419.     } if pop
  420. } bind
  421. /ResourceFileName
  422.     { /GenericResourceDir getsystemparam 
  423.       Category .namestring concatstrings
  424.       /GenericResourcePathSep getsystemparam concatstrings
  425.       .genericrfn
  426.     } bind
  427.  
  428.         % Additional entries
  429.  
  430. % Unfortunately, we can't create the real .Instances dictionary now,
  431. % because if someone copies the Generic category (which pp. 95-96 of the
  432. % 2nd Edition Red Book says is legitimate), they'll wind up sharing
  433. % the .Instances.  Instead, we have to create .Instances on demand,
  434. % just like the entry in localinstancedict.
  435. % We also have to prevent anyone from creating instances of Generic itself.
  436. /.Instances //.emptydict
  437.  
  438. /.LocalInstances
  439.     { localinstancedict Category .knownget not { //.emptydict } if
  440.     } bind
  441. /.GetInstance
  442.     { currentglobal
  443.        { .Instances exch .knownget }
  444.        { .LocalInstances 1 index .knownget
  445.           { exch pop true }
  446.           { .Instances exch .knownget }
  447.          ifelse
  448.        }
  449.       ifelse
  450.     } bind
  451. /.CheckResource
  452.     { true
  453.     } bind
  454. /.vmused {
  455.         % - .vmused <usedvalue>
  456.         % usedvalue = vmstatus in global + vmstatus in local.
  457.   0 2 {
  458.     .currentglobal not .setglobal
  459.     vmstatus pop exch pop add
  460.   } repeat
  461. } bind def
  462. /.DoLoadResource {
  463.         % .LoadResource may push entries on the operand stack.
  464.         % It is an undocumented feature of Adobe implementations,
  465.         % which we must match for the sake of some badly written
  466.         % font downloading code, that such entries are popped
  467.         % automatically.
  468.     count 1 index cvlit .vmused
  469.         % Stack: key count litkey memused
  470.     {.LoadResource} 4 1 roll 4 .execn
  471.         % Stack: ... count key memused
  472.     .vmused exch sub
  473.     1 index .getvminstance not {
  474.       pop dup /undefinedresource signalerror    % didn't load
  475.     } if
  476.     dup 1 1 put
  477.     2 3 -1 roll put
  478.         % Stack: ... count key
  479.     exch count 1 sub exch sub {exch pop} repeat
  480. } bind
  481. /.LoadResource
  482.     { dup .ResourceFile
  483.        { exch pop currentglobal
  484.           { .runresource }
  485.           { true setglobal { .runresource } stopped false setglobal { stop } if }
  486.          ifelse
  487.        }
  488.        { dup /undefinedresource signalerror
  489.        }
  490.      ifelse
  491.     } bind
  492. /.ResourceFile
  493.     { currentdict /ResourceFileName known
  494.        { mark 1 index 100 string { ResourceFileName }
  495.          .internalstopped
  496.           { cleartomark false }
  497.           { exch pop findlibfile
  498.          { exch pop exch pop true }
  499.          { pop false }
  500.         ifelse
  501.           }
  502.          ifelse
  503.        }
  504.        { false }
  505.       ifelse
  506.     } bind
  507.  
  508. .dicttomark
  509. /Category defineresource pop
  510.  
  511. % Fill in the rest of the Category category.
  512. /Category /Category findresource dup
  513. /Generic /Category findresource begin {
  514.   /FindResource /ResourceForAll /ResourceStatus /.ResourceFileStatus
  515.   /UndefineResource /ResourceFileName
  516.   /.ResourceFile /.LoadResource /.DoLoadResource
  517. } { dup load put dup } forall
  518. pop readonly pop end
  519.  
  520. (END GENERIC) VMDEBUG
  521.  
  522. % Define the fixed categories.
  523.  
  524. mark
  525.     % Non-Type categories with existing entries.
  526.  /ColorSpaceFamily
  527.    { }    % These must be deferred, because optional features may add some.
  528.  /Emulator
  529.    mark EMULATORS { cvn } forall .packtomark
  530.  /Filter
  531.    { }    % These must be deferred, because optional features may add some.
  532.  /IODevice
  533.     % Loop until the .getiodevice gets a rangecheck.
  534.    errordict /rangecheck 2 copy get
  535.    errordict /rangecheck { pop stop } put    % pop the command
  536.    mark 0 { {
  537.     dup .getiodevice dup null eq { pop } { exch } ifelse 1 add
  538.    } loop} .internalstopped
  539.    pop pop pop .packtomark
  540.    4 1 roll put
  541.    .clearerror
  542.     % Type categories listed in the Red Book.
  543.  /ColorRenderingType
  544.    { }    % These must be deferred, because optional features may add some.
  545.  /FMapType
  546.    { }    % These must be deferred, because optional features may add some.
  547.  /FontType
  548.    { }    % These must be deferred, because optional features may add some.
  549.  /FormType
  550.    { }    % These must be deferred, because optional features may add some.
  551.  /HalftoneType
  552.    { }    % These must be deferred, because optional features may add some.
  553.  /ImageType
  554.    { }    % Deferred, optional features may add some.
  555.  /PatternType
  556.    { }  % Deferred, optional features may add some.
  557.     % Type categories added since the Red Book.
  558.  /setsmoothness where {
  559.    pop /ShadingType { }    % Deferred, optional features may add some.
  560.  } if
  561. counttomark 2 idiv
  562.  { mark
  563.  
  564.         % Standard entries
  565.  
  566.         % We'd like to prohibit defineresource,
  567.         % but because optional features may add entries, we can't.
  568.         % We can at least require that the key and value match.
  569.    /DefineResource
  570.     { currentglobal not
  571.        { /defineresource load /invalidaccess signalerror }
  572.        { 2 copy ne
  573.           { /defineresource load /rangecheck signalerror }
  574.           { dup .Instances 4 -2 roll .growput }
  575.          ifelse
  576.        }
  577.       ifelse
  578.     } bind
  579.    /UndefineResource
  580.     { /undefineresource load /invalidaccess signalerror } bind
  581.    /FindResource
  582.     { .Instances 1 index .knownget
  583.        { exch pop }
  584.        { /findresource load /undefinedresource signalerror }
  585.       ifelse
  586.     } bind
  587.    /ResourceStatus
  588.     { .Instances exch known { 0 0 true } { false } ifelse } bind
  589.    /ResourceForAll
  590.     /Generic /Category findresource /ResourceForAll get
  591.  
  592.         % Additional entries
  593.  
  594.    counttomark 2 add -1 roll
  595.    dup length dict dup begin exch { dup def } forall end
  596.         % We'd like to make the .Instances readonly here,
  597.         % but because optional features may add entries, we can't.
  598.    /.Instances exch
  599.    /.LocalInstances    % used by ResourceForAll
  600.     0 dict def
  601.  
  602.    .dicttomark /Category defineresource pop
  603.  } repeat pop
  604.  
  605. (END FIXED) VMDEBUG
  606.  
  607. % Define the other built-in categories.
  608.  
  609. /.definecategory    % <name> -mark- <key1> ... <valuen> .definecategory -
  610.  { counttomark 2 idiv 2 add        % .Instances, Category
  611.    /Generic /Category findresource dup maxlength 3 -1 roll add
  612.    dict .copydict begin
  613.    counttomark 2 idiv { def } repeat pop    % pop the mark
  614.    currentdict end /Category defineresource pop
  615.  } bind def
  616.  
  617. /ColorRendering mark /InstanceType /dicttype .definecategory
  618. % ColorSpace is defined below
  619. % Encoding is defined below
  620. % Font is defined below
  621. /Form mark /InstanceType /dicttype .definecategory
  622. /Halftone mark /InstanceType /dicttype .definecategory
  623. /Pattern mark /InstanceType /dicttype .definecategory
  624. /ProcSet mark /InstanceType /dicttype .definecategory
  625. % Added since the Red Book:
  626. /ControlLanguage mark /InstanceType /dicttype .definecategory
  627. /HWOptions mark /InstanceType /dicttype .definecategory
  628. /Localization mark /InstanceType /dicttype .definecategory
  629. /OutputDevice mark /InstanceType /dicttype .definecategory
  630. /PDL mark /InstanceType /dicttype .definecategory
  631. % CIDFont, CIDMap, and CMap are defined in gs_cidfn.ps
  632. % FontSet is defined in gs_cff.ps
  633. % IdiomSet is defined in gs_ll3.ps
  634. % InkParams and TrapParams are defined in gs_trap.ps
  635.  
  636. (END MISC) VMDEBUG
  637.  
  638. % Define the ColorSpace category.
  639.  
  640. /.defaultcsnames mark
  641.   /DefaultGray 0
  642.   /DefaultRGB 1
  643.   /DefaultCMYK 2
  644. .dicttomark readonly def
  645.  
  646. % The "hooks" are no-ops here, redefined in LL3.
  647. /.definedefaultcs {    % <index> <value> .definedefaultcs -
  648.   pop pop
  649. } bind def
  650. /.undefinedefaultcs {    % <index> .undefinedefaultcs -
  651.   pop
  652. } bind def
  653.  
  654. /ColorSpace mark
  655.  
  656. /InstanceType /arraytype
  657.  
  658. % We keep track of whether there are any local definitions for any of
  659. % the Default keys.  This information must get saved and restored in
  660. % parallel with the local instance dictionary, so it must be stored in
  661. % local VM.
  662. userdict /.localcsdefaults false put
  663.  
  664. /DefineResource {
  665.   2 copy /Generic /Category findresource /DefineResource get exec
  666.   exch pop
  667.   exch //.defaultcsnames exch .knownget {
  668.     1 index .definedefaultcs
  669.     currentglobal not { .userdict /.localcsdefaults true put } if
  670.   } if
  671. } bind
  672.  
  673. /UndefineResource {
  674.   dup /Generic /Category findresource /UndefineResource get exec
  675.   //.defaultcsnames 1 index .knownget {
  676.     % Stack: resname index
  677.     currentglobal {
  678.       .undefinedefaultcs pop
  679.     } {
  680.     % We removed the local definition, but there might be a global one.
  681.       exch .GetInstance {
  682.     0 get .definedefaultcs
  683.       } {
  684.     .undefinedefaultcs
  685.       } ifelse
  686.     % Recompute .localcsdefaults by scanning.  This is rarely needed.
  687.       .userdict /.localcsdefaults false //.defaultcsnames {
  688.     pop .LocalInstances exch known { pop true exit } if
  689.       } forall put
  690.     } ifelse
  691.   } {
  692.     pop
  693.   } ifelse
  694. } bind
  695.  
  696. .definecategory            % ColorSpace
  697.  
  698. % Define the Encoding category.
  699.  
  700. /Encoding mark
  701.  
  702. /InstanceType /arraytype
  703.  
  704. % Handle already-registered encodings, including lazily loaded encodings
  705. % that aren't loaded yet.
  706.  
  707. /.Instances mark
  708.   EncodingDirectory
  709.    { dup length 256 eq { [ exch readonly 0 -1 ] } { pop [null 2 -1] } ifelse
  710.    } forall
  711. .dicttomark
  712.  
  713. /.ResourceFileDict mark
  714.   EncodingDirectory
  715.    { dup length 256 eq { pop pop } { 0 get } ifelse
  716.    } forall
  717. .dicttomark
  718.  
  719. /ResourceFileName
  720.  { .ResourceFileDict 2 index .knownget
  721.     { exch copy exch pop }
  722.     { /Generic /Category findresource /ResourceFileName get exec }
  723.    ifelse
  724.  } bind
  725.  
  726. .definecategory            % Encoding
  727.  
  728. % Make placeholders in level2dict for the redefined Encoding operators,
  729. % so that they will be swapped properly when we switch language levels.
  730.  
  731. /.findencoding /.findencoding load def
  732. /findencoding /findencoding load def
  733. /.defineencoding /.defineencoding load def
  734.  
  735. (END ENCODING) VMDEBUG
  736.  
  737. % Define the Font category.
  738.  
  739. /.fontstatus {        % <fontname> .fontstatus <fontname> <found>
  740.   {        % Create a loop context just so we can exit it early.
  741.         % Check Fontmap.
  742.     Fontmap 1 index .knownget {
  743.       {
  744.     dup type /nametype eq {
  745.       .fontstatus { pop null exit } if
  746.     } {
  747.       dup type /stringtype eq {
  748.         findlibfile { closefile pop null exit } if pop
  749.       } {
  750.         % Procedure, assume success.
  751.         pop null exit
  752.       } ifelse
  753.     } ifelse
  754.       } forall dup null eq { pop true exit } if
  755.     } if
  756.         % Convert names to strings; give up on other types.
  757.     dup type /nametype eq { .namestring } if
  758.     dup type /stringtype ne { false exit } if
  759.         % Check the resource directory.
  760.     dup .fonttempstring /FontResourceDir getsystemparam .genericrfn
  761.     status {
  762.       pop pop pop pop true exit
  763.     } if
  764.         % Check for a file on the search path with the same name
  765.         % as the font.
  766.     findlibfile { closefile true exit } if
  767.         % Scan a FONTPATH directory and try again.
  768.     .scannextfontdir not { false exit } if
  769.   } loop
  770. } bind def
  771.  
  772. /Font mark
  773.  
  774. /InstanceType /dicttype
  775.  
  776. /DefineResource
  777.     { 2 copy //definefont exch pop
  778.       /Generic /Category findresource /DefineResource get exec
  779.     } bind
  780. /UndefineResource
  781.     { dup //undefinefont
  782.       /Generic /Category findresource /UndefineResource get exec
  783.     } bind
  784. /FindResource {
  785.     dup .getvminstance {
  786.       exch pop 0 get
  787.     } {
  788.       dup ResourceStatus {
  789.         pop 1 gt { .loadfontresource } { .GetInstance pop 0 get } ifelse
  790.       } {
  791.         .loadfontresource
  792.       } ifelse
  793.     } ifelse
  794. } bind
  795. /ResourceForAll {
  796.     { .scannextfontdir not { exit } if } loop
  797.     /Generic /Category findresource /ResourceForAll get exec
  798. } bind
  799. /.ResourceFileStatus {
  800.     .fontstatus { pop 2 -1 true } { pop false } ifelse
  801. } bind
  802.  
  803. /.loadfontresource {
  804.     dup vmstatus pop exch pop exch
  805.         % Hack: rebind .currentresourcefile so that all calls of
  806.         % definefont will know these are built-in fonts.
  807.     currentfile {pop //findfont exec} .execasresource  % (findfont is a procedure)
  808.     exch vmstatus pop exch pop exch sub
  809.         % stack: name font vmused
  810.         % findfont has the prerogative of not calling definefont
  811.         % in certain obscure cases of font substitution.
  812.     2 index .getvminstance {
  813.       dup 1 1 put
  814.       2 3 -1 roll put
  815.     } {
  816.       pop
  817.     } ifelse exch pop
  818. } bind
  819.  
  820. /.Instances FontDirectory length 2 mul dict
  821.  
  822. .definecategory            % Font
  823.  
  824. % Redefine font "operators".
  825. /.definefontmap
  826.  { /Font /Category findresource /.Instances get
  827.    dup 3 index known
  828.     { pop
  829.     }
  830.     { 2 index
  831.         % Make sure we create the array in global VM.
  832.       .currentglobal true .setglobal
  833.       [null 2 -1] exch .setglobal
  834.       .growput
  835.     }
  836.    ifelse
  837.    //.definefontmap exec
  838.  } bind def
  839.  
  840. % Make sure the old definitions are still in systemdict so that
  841. % they will get bound properly.
  842. systemdict begin
  843.   /.origdefinefont /definefont load def
  844.   /.origundefinefont /undefinefont load def
  845.   /.origfindfont /findfont load def
  846. end
  847. /definefont {
  848.   /Font defineresource
  849. } bind odef
  850. /undefinefont {
  851.   /Font undefineresource
  852. } bind odef
  853. % The Red Book requires that findfont be a procedure, not an operator,
  854. % but it still needs to restore the stacks reliably if it fails.
  855. /.findfontop {
  856.   /Font findresource
  857. } bind odef
  858. /findfont {
  859.   .findfontop
  860. } bind def    % Must be a procedure, not an operator
  861.  
  862. % Remove initialization utilities.
  863. currentdict /.definecategory .undef
  864. currentdict /.emptydict .undef
  865.  
  866. end                % level2dict
  867.  
  868. % Convert deferred resources after we finally switch to Level 2.
  869.  
  870. /.fixresources {
  871.     % Encoding resources
  872.   EncodingDirectory
  873.    { dup length 256 eq
  874.       { /Encoding defineresource pop }
  875.       { pop pop }
  876.      ifelse
  877.    } forall
  878.   /.findencoding { /Encoding findresource } bind def
  879.   /findencoding /.findencoding load def        % must be a procedure
  880.   /.defineencoding { /Encoding defineresource pop } bind def
  881.     % ColorRendering resources and ProcSet
  882.   systemdict /ColorRendering .knownget {
  883.     /ColorRendering exch /ProcSet defineresource pop
  884.     systemdict /ColorRendering undef
  885.     /Default currentcolorrendering /ColorRendering defineresource pop
  886.   } if
  887.     % ColorSpace resources
  888.   systemdict /CIEsRGB .knownget {
  889.     /sRGB exch /ColorSpace defineresource pop
  890.     systemdict /CIEsRGB undef
  891.   } if
  892.     % ColorSpaceFamily resources
  893.   colorspacedict { pop dup /ColorSpaceFamily defineresource pop } forall
  894.     % Filter resources
  895.   filterdict { pop dup /Filter defineresource pop } forall
  896.     % FontType and FMapType resources
  897.   buildfontdict { pop dup /FontType defineresource pop } forall
  898.   mark
  899.     buildfontdict 0 known { 2 3 4 5 6 7 8 } if
  900.     buildfontdict 9 known { 9 } if
  901.   counttomark { dup /FMapType defineresource pop } repeat pop
  902.     % FormType resources
  903.   .formtypes { pop dup /FormType defineresource pop } forall
  904.     % HalftoneType resources
  905.   .halftonetypes { pop dup /HalftoneType defineresource pop } forall
  906.     % ColorRenderingType resources
  907.   .colorrenderingtypes {pop dup /ColorRenderingType defineresource pop} forall
  908.     % ImageType resources
  909.   .imagetypes { pop dup /ImageType defineresource pop } forall
  910.     % PatternType resources
  911.   .patterntypes { pop dup /PatternType defineresource pop } forall
  912.     % Make the fixed resource categories immutable.
  913.   /.shadingtypes where {
  914.     pop .shadingtypes { pop dup /ShadingType defineresource pop } forall
  915.   } if
  916.   [ /ColorSpaceFamily /Emulator /Filter /IODevice /ColorRenderingType
  917.     /FMapType /FontType /FormType /HalftoneType /ImageType /PatternType
  918.     /.shadingtypes where { pop /ShadingType } if
  919.   ] {
  920.     /Category findresource
  921.     dup /.Instances get readonly pop
  922.     .LocalInstances readonly pop
  923.     readonly pop
  924.   } forall
  925.     % clean up
  926.   systemdict /.fixresources undef
  927. } bind def
  928.